#include <iostream>
#include <string>
using namespace std;
/*
   假设根节点在中序遍历中的位置为pos，树的结点数为len，即 len=inorder.length()
   代码：pos = inorder.find(preorder[0]) or pos = inorder.find(postorder[postorder.size()-1]) 先序遍历(NLR), 根节点编号(0),
   左子树编号(1~pos), 右子树编号(pos+1~len-1) 中序遍历(LNR),
   左子树编号(0~pos-1), 根节点编号(pos), 右子树编号(pos+1~len-1) 后序遍历(LRN),
   左子树编号(0~pos-1), 右子树编号(pos~len-2), 根点编号(len-1)
*/
void postorder(
    string preorder,
    string inorder) { // 由先序遍历+中序遍历序列，递归实现后序遍历 (LRN)
    int len = preorder.length();
    if (len == 0)
        return;
    if (len == 1) { // 单个结点
        cout << preorder[0];
        return;
    }
    int pos = inorder.find(
        preorder[0]); // 查找根节点在中序序列中的位置，通过根节点划分左右子树
                      // 类似于后序遍历过程
    postorder(preorder.substr(1, pos), inorder.substr(0, pos)); // 后序遍历左子树
    postorder(preorder.substr(pos + 1, len - pos - 1), inorder.substr(pos + 1, len - pos - 1)); // 后序遍历右子树，pos从0开始，所以len-pos-1
    cout << preorder[0]; // 最后输出根节点
}
void preorder(
    string inorder,
    string postorder) // 由中序遍历+后序遍历序列，递归实现先序序列 (NLR)
{
    int len = postorder.length();
    if (len == 0) // 空树
        return;
    if (len == 1) // 单个结点
    {
        cout << inorder[0];
        return;
    }
    int pos = inorder.find(postorder[len - 1]);
    // 类似于先序遍历过程
    cout << postorder[len - 1];
    preorder(inorder.substr(0, pos),
             postorder.substr(0, pos)); // 先序遍历左子树
    preorder(inorder.substr(pos + 1, len - pos - 1),
             postorder.substr(pos, len - pos - 1)); // 先序遍历右子树
}

int main() {
    string s1, s2;
    while (cin >> s1 >> s2) {
        postorder(s1, s2);
        // preorder(s1, s2);
        cout << endl;
    }
}

// //前序遍历 非递归
// void _PreOrder(Node *root) { 
//     stack<Node *> tty;
//     while (root != NULL || !tty.empty()) {
//         if (root) {
//             cout << root->_data << " ";
//             tty.push(root);
//             root = root->lchild;
//         } else {
//             Node *temp = tty.top();
//             tty.pop();
//             root = temp->rchild;
//         }
//     }
// }

struct BitNode {
    int val;
    BitNode *lchild;
    BitNode *rchild;
    BitNode(int v, BitNode *lch, BitNode *rch)
        : val(v), lchild(lch), rchild(rch){};
};

#include <stack>

void _PreOrder(BitNode* root) {
    if (root == NULL) {
        return;
    }
    stack<BitNode*> temp_stack;
    while ( root != nullptr || !temp_stack.empty() ) {
        if ( root != nullptr ) {
            cout << root->val << endl;
            temp_stack.push(root);
            root = root->lchild;
        } else {
            BitNode* tmp = temp_stack.top();
            temp_stack.pop();
            root = tmp->rchild;
        }
    }
}

void _InOrder(BitNode *root) //中序遍历 非递归
{
    if (root == NULL) {
        return;
    }
    stack<BitNode*> temp_stack;
    while (root != NULL || !temp_stack.empty()) {
        while (root) {
            temp_stack.push(root);
            root = root->lchild;
        }
        //此时出了循环走到了最左叶子节点
        BitNode *temp = temp_stack.top();
        temp_stack.pop();
        cout << temp->val << " ";
        root = temp->rchild;
    }
}

void _PostOrder(BitNode *root) //后序遍历 左 右 根  非递归
{
    if (root == NULL) {
        return;
    }
    stack<BitNode *> tty;
    BitNode *PreNode = NULL; //上一个访问的结点
    tty.push(root);
    while (!tty.empty()) {
        BitNode *cur = tty.top();
        //访问的当前节点左右孩子均为空或者当前节点左右子树均已经访问过
        if ((cur->lchild == NULL && cur->rchild == NULL) ||
            ((PreNode != NULL) &&
             (PreNode == cur->lchild || PreNode == cur->rchild))) {
            cout << cur->val << " ";
            tty.pop();
            PreNode = cur;
        } else {
            if (cur->rchild != NULL) {
                tty.push(cur->rchild);
            }
            if (cur->lchild != NULL) {
                tty.push(cur->lchild);
            }
        }
    }
}

#include <queue>

// 层序遍历 使用queue
void _FloorOrder(BitNode *root) {
    if (root == nullptr)
        return;
    queue<BitNode *> temp_queue;
    temp_queue.push(root);
    while (!temp_queue.empty()) {
        BitNode* temp = temp_queue.front();
        cout << temp->val << " "; // 访问
        temp_queue.pop();
        if (temp->lchild!=nullptr) {
            temp_queue.push(temp->lchild);
        }
        if (temp->rchild!=nullptr) {
            temp_queue.push(temp->rchild);
        }
    }
}